1-. ¿Por qué una matriz equivale a una transformación lineal entre espacios vectoriales?
Un espacio vectorial se genera por cualquier conjunto de vectores x1, ..., xk; sus columnas son el efecto sobre los vectores canónicos. Una matriz es la colección de un conjunto de vectores. un vector es una entidad que tiene longitud y dirección
2.- ¿Cuál es el efecto de transformación lineal de una matriz diagonal y el de una matriz ortogonal?
Es el determinante, que graficamente puede interpretarse como una distorsión del volumen/área. En el caso de la matriz diagonal, la transformación lineal desemboca en el cambio del volumen. En el caso de la matriz ortogonal, la transformación lineal impacta por medio de reflexiones y rotaciones.
3.- ¿Qué es la descomposición en valores singulares de una matriz?
La descomposición en valores singulares de una matriz muestra que toda transformación lineal es una rotación + redimensión de los ejes canónicos + rotación; es decir, muestra los ejes de máxima distorsión de una matriz.
4.- ¿Qué es diagonalizar una matriz y que representan los eigenvectores?
Diagonalizar una matriz es encontrar base de eigenvectores. Los eigenvectores muestran la solución a un problema de optimización
5.- ¿Intuitivamente qué son los eigenvectores?
Muestran la máxima distorsión Son las direcciones a lo largo de las cuales la transformación lineal ocurre solamente por el escalamiento, mientras que los valores propios λi son las escalas a lo largo de esas direcciones. Para matrices simétricas, los vectores propios son ortogonales entre sí.
6.- ¿Cómo interpretas la descomposición en valores singulares como una composición de tres tipos de transformaciones lineales simples?
7.- ¿Qué relación hay entre la descomposición en valores singulares y la diagonalización?
Si A es una matriz de mn, los valores singulares de A son las raices cuadradas de los autovalores de (A^T)A
8.- ¿Cómo se usa la descomposición en valores singulares para dar un aproximación de rango menor a una matriz?
La descomposición en valores singulares provee una aproximación de la matriz en cuestión que corresponde solamente a los k primeros valores singulares y los correspondientes vectores singulares siendo no nulos.
9.- Describe el método de minimización por descenso gradiente
Consiste en la selección del elemento que maximiza el ascenso o descenso (según sea el caso) una función con base en un conjunto de elementos disponibles
El método del gradiente consiste en un algortimo específico para la resolución de un modelo de programación lineal sin restricciones, perteneciente a la categoría de algoritmos generales de descenso, donde la búsqueda de un mínimo esta asociado a la resolución secuencial de una serie de problemas unidimensionales.
10.- Menciona 4 ejemplo de problemas de optimización (dos con restricciones y dos sin restricciones) que te parecan interesantes como Científico de Datos
Eficiencia terminal de los alumnos en las carreras de Ciencias de la Salud en México; comparando los resultados entre universidades públicas y privadas Reducir el costo de la nómina docente en la Universidad del Valle de México Programa social para maximizar el numero de beneficiarios a salud pública en personas de la 3ra edad Sistema que permita mapear la congestión vehicular para agilizar la movilidad y así optimizar los espacios de las ciudades
Recibir el path de un archivo de imagen png y convertirlo en una matriz numérica que represente a la versión en blanco y negro de la imagen. Ayuda "https://stackoverflow.com/questions/27026866/convert-an-image-to-2d-array-in-python"
Realizar y verificar la descomposición svd
Usar la descomposición para dar una aproximación de grado k de la imagen.
Para alguna imagen de su elección, elegir distintos valores de aproximación a la imagen original.
Contestar, ¿qué tiene que ver este proyecto con compresión de imágenes?
In [4]:
import numpy as np # funciones numéricas (arrays, matrices, etc.)
import PIL.Image # funciones para cargar y manipular imágenes
In [5]:
im = PIL.Image.open("/Users/Karen/image.jpg")
col,row = im.size
image = np.zeros((row*col, 5))
pixels = im.load()
print(pixels[188,266])
for i in range(col):
for j in range(row):
#print("i=%d, j=%d" % (i,j))
r,g,b = pixels[i,j]
image[i*col + j,:] = r,g,b,i,j
In [6]:
im.size
Out[6]:
In [7]:
image
Out[7]:
In [8]:
print(image)
In [9]:
image.shape
Out[9]:
In [10]:
import numpy as np
RH = np.linalg
In [11]:
U, s, Vh = RH.svd(image, full_matrices=False)
assert np.allclose(image, np.dot(U, np.dot(np.diag(s), Vh)))
In [12]:
R_H = np.dot(np.dot(U, np.diag(s)), Vh)
print(np.std(image), np.std(R_H), np.std(image - R_H))
In [13]:
U
Out[13]:
In [14]:
s
Out[14]:
In [15]:
s.shape
Out[15]:
In [25]:
Vh
Out[25]:
In [26]:
import scipy.linalg as sc
In [27]:
S = sc.diagsvd(s, 5, 5)
S
Out[27]:
In [28]:
U @ S @ Vh
Out[28]:
In [33]:
from scipy import *
from pylab import *
im = imread("/Users/Karen/image.jpg")[:,:,0]
gray()
figure(1)
imshow(image)
Out[33]:
In [36]:
m,n = img.shape
m,n
Out[36]:
In [37]:
U,s,Vt = svd(img)
In [38]:
Vt.shape
Out[38]:
In [39]:
s.shape
Out[39]:
In [40]:
S = resize(s,[m,1])*eye(m,n)
S
Out[40]:
In [41]:
S.shape
Out[41]:
In [45]:
m,n = img.shape
U,s,Vt = svd(img)
S = resize(s,[m,1])*eye(m,n)
k = 3
imshow(dot(U[:,1:k],dot(S[1:k,1:k],Vt[1:k,:])))
show()
In [46]:
k = 6
imshow(dot(U[:,1:k],dot(S[1:k,1:k],Vt[1:k,:])))
show()
In [ ]:
k = 10
imshow(dot(U[:,1:k],dot(S[1:k,1:k],Vt[1:k,:])))
show()
In [48]:
k = 20
imshow(dot(U[:,1:k],dot(S[1:k,1:k],Vt[1:k,:])))
show()
In [49]:
k = 25
imshow(dot(U[:,1:k],dot(S[1:k,1:k],Vt[1:k,:])))
show()
¿Que tiene que ver este proyecto con la compresión de imágenes? La descomposición en valores singulares aplicado en el tratamiento de imágenes tiene como objetivo, comprimir la información implícita de una matriz; para ello, prevalecen los valores singulares que son determinantes en la formación de la matriz y, en ocasiones, permite eliminar el ruido de la imagen.
Ahora veremos la aplicación a pseudoinversa y sistemas de ecuaciones Programar una función que dada cualquier matriz devuelva la pseudainversa usando la descomposición SVD. Hacer otra función que resuelva cualquier sistema de ecuaciones de la forma Ax=b usando esta pseudoinversa.
In [2]:
from numpy import *
import numpy as np
def gen_mat(i,j):
A = floor(random.rand(i,j)*20-0) # se está haciendo una matriz aleatoria de 5x5
b = floor(random.rand(j,1)*20-0) # este es el vector de resultados b
return A,b
In [11]:
A,b= gen_mat(5,5)
In [12]:
A
Out[12]:
In [13]:
b
Out[13]:
In [14]:
#Esto sólo sirve para matrices cuadradas.
def Inversa(A):
if((A.shape[0] == A.shape[1])):
U,s,V=np.linalg.svd(A)
Inversa = np.dot(np.dot(V.T,linalg.inv(diag(s))),U.T)
return Inversa
else:
return "La Matriz no es cuadrada, calcula la pseudoinversa"
In [15]:
w=Inversa(A)
w
Out[15]:
In [16]:
m,n=A.shape
m,n
Out[16]:
In [17]:
U, s, V = np.linalg.svd(A)
In [18]:
s
Out[18]:
In [19]:
U.shape
Out[19]:
In [20]:
V.shape
Out[20]:
In [21]:
S=eye(m,n)
S
Out[21]:
In [22]:
S = resize(s,[m,1])*eye(m,n)
S
Out[22]:
In [23]:
Sigma = np.zeros([U.shape[1],V.shape[0]])
Sigma
Out[23]:
In [24]:
def P_Inversa(A):
import numpy as np
if isinstance(A, np.ndarray):
U, s, V = np.linalg.svd(A)
m,n=A.shape
S = resize(s,[m,1])*eye(m,n)
for i in range(S.shape[0]):
for j in range(S.shape[1]):
if (i == j):
if (s[i] == 0):
S[i,j] == 0
else:
S[i,j] = 1/s[i]
P_Inversa = np.dot(np.dot(V.T,S.T),U.T)
return(P_Inversa)
else:
return "Errores en la especificación"
In [25]:
A_I=P_Inversa(A)
A_I
Out[25]:
In [27]:
def Solucion(A,b):
import numpy as np
if isinstance(A, np.ndarray):
if isinstance(b, np.ndarray):
if((A.shape[1] == b.shape[0])):#la matriz y el vector son compatibles
if((A.shape[0] == A.shape[1])):
A_inv=Inversa(A)
x_sol = np.dot(A_inv,b)
else:
A_inv=P_Inversa(A)
x_sol = np.dot(A_inv.T,b)
return(x_sol)
else:
return "A y b son incompatibles"
else:
return "Problemas con b"
else:
return "Problemas con A"
In [28]:
x = Solucion(A,b)
x
Out[28]:
Dado el sistema Ax=b donde A = [[1,1],[0,0]] y b puede tomar distintos valores. a) Observar que pasa si b está en la imagen de A (contestar cuál es la imagen) y si no está (ej. b = [1, 1]). b) Contestar, ¿la solución resultante es única? Si hay más de una solución, investigar que caracteriza a la solución directa. c) Repetir cambiando A = [[1,1],[0, 1e-32]], ¿en este caso, la solución es única? ¿Cambia el valor devuelto de x en cada posible valor de b en el punto anterior?
In [29]:
import numpy as np
A1 =np.array([[1,1],[0,0]])
A1
Out[29]:
In [30]:
b1=np.array([[1],[1]])
b1
Out[30]:
In [31]:
x1 = Solucion(A1,b1)
x1
In [32]:
d=np.linalg.det(A1)
d
Out[32]:
In [33]:
def Solucion(A,b):
import numpy as np
import warnings
if isinstance(A, np.ndarray):
if isinstance(b, np.ndarray):
if((A.shape[1] == b.shape[0])):#la matriz y el vector son compatibles
if((A.shape[0] == A.shape[1]) and np.linalg.det(A) != 0):
A_inv=Inversa(A)
x_sol = np.dot(A_inv,b)
return(x_sol)
elif (np.linalg.det(A)==0):
A_inv=P_Inversa(A)
x_sol = np.dot(A_inv.T,b)
print(x_sol)
print("La Matriz A es singular")
else:
A_inv=P_Inversa(A)
x_sol = np.dot(A_inv.T,b)
return(x_sol)
else:
return "A y b son incompatibles"
else:
return "Problemas con b"
else:
return "Problemas con A"
In [34]:
x1 = Solucion(A1,b1)
x1
Prueba con valores distintos
In [35]:
b2=np.array([[1],[2]])
x2 = Solucion(A1,b2)
x2
In [36]:
b3=np.array([[1],[0]])
x3 = Solucion(A1,b3)
x3
La Imagen de A, son todas las posibles combinaciones lineales de las columnas de A.
Cambiando el valor de la posición [2,2] de la Matriz A1 por el valor 1e-32.
In [39]:
A2 =np.array([[1,1],[0,1e-32]])
A2
Out[39]:
In [40]:
x4 = Solucion(A2,b1)
x4
Out[40]:
In [41]:
x5 = Solucion(A2,b2)
x5
Out[41]:
Al cambiar la entrada [2,2] y correr para diferentes valores de b, observamos que el resultado esta determinado por la elección de b[2,1]. En este caso las soluciones parecen ser de la forma [-x,x] donde x=b[2,1]. Toma un valor muy grande. El pequeño cambio en la Matriz A hace que las soluciones sean muy diferenetes.
Ejercicio 3 Utilizar la paquetería pandas para trabajar el ajuste por mínimos cuadrados a un conjunto de datos.
In [61]:
import numpy as np
from pandas import DataFrame
import pandas as pd
import os
Programar un script que lea el archivo study_vs_sat.csv y lo almacene como un dataframe en pandas.
In [62]:
tabla = pd.read_csv("/Users/karen/study_vs_sat.csv")
tabla
Out[62]:
Plantear un problema de optimización que intente hacer una aproximación de la forma: sat_score ~ alpha + beta*study_hoursi, con un valor para cada individuo
In [63]:
df=pd.DataFrame(tabla)
df
Out[63]:
Plantear como un problema de optimización que intente hacer una aproximación de la forma sat_score ~ alpha + beta*study_hours minimizando la suma de los errores de predicción al cuadrado. Pueden consultar este link https://en.wikipedia.org/wiki/Simple_linear_regression ¿Cuál es el gradiente de la función que se quiere optimizar (hint: las variables que queremos optimizar son alpha y beta)?
In [64]:
import statsmodels.formula.api as sm
In [65]:
result = sm.ols(formula="sat_score ~ study_hours", data=df).fit()
print (result.params)
In [66]:
study_hours=tabla["study_hours"]
sat_score=tabla["sat_score"]
In [67]:
Suma_study_hours = sum(study_hours)
Suma_sat_score = sum(sat_score)
Suma_hours_score = sum(study_hours*sat_score)
Suma_hours_2 = sum(study_hours**2)
Suma_score_2 = sum(sat_score**2)
obs = len(study_hours)
In [68]:
Beta = (obs*Suma_hours_score - Suma_study_hours*Suma_sat_score)/(obs*Suma_hours_2 - Suma_study_hours**2)
Beta
Out[68]:
In [69]:
Alpha = Suma_sat_score/obs - (Beta*Suma_study_hours)/obs
Alpha
Out[69]:
In [70]:
def mco(b0, b1, X):
rows = len(X)
sat_score_e1 = np.array([b0 + b1*X[i] for i in range(rows)])
return(sat_score_e1)
In [71]:
sat_score_e1=mco(Alpha, Beta, study_hours)
sat_score_e1
Out[71]:
In [ ]: